home *** CD-ROM | disk | FTP | other *** search
/ Champak 145 / (Vol 145) Dec 21 2011.iso / Games / jump-n-rolla.swf / scripts / __Packages / mochi / as2 / MochiAd.as
Encoding:
Text File  |  2011-12-21  |  31.4 KB  |  994 lines
  1. function ┬º\x04\x05┬º()
  2. {
  3.    set("\x03",1038 % 511 * true);
  4.    ┬º┬ºpush("\x03");
  5.    if("\x01")
  6.    {
  7.    }
  8.    return eval(┬º┬ºpop());
  9. }
  10. var ┬º\x01┬º = 832 + "\x04\x05"();
  11. while(true)
  12. {
  13.    if(eval("\x01") == 848)
  14.    {
  15.       set("\x01",eval("\x01") - 278);
  16.       ┬º┬ºpush(true);
  17.       continue;
  18.    }
  19.    if(eval("\x01") == 570)
  20.    {
  21.       set("\x01",eval("\x01") + 373);
  22.       if(function ┬º\x04\x05┬º()
  23.       {
  24.          set("\x03",1038 % 511 * true);
  25.          ┬º┬ºpush("\x03");
  26.          if("\x01")
  27.          {
  28.          }
  29.          return eval(┬º┬ºpop());
  30.       })
  31.       {
  32.          set("\x01",eval("\x01") - 870);
  33.       }
  34.       continue;
  35.    }
  36.    if(eval("\x01") == 972)
  37.    {
  38.       set("\x01",eval("\x01") - 155);
  39.       ┬º┬ºpush(true);
  40.       continue;
  41.    }
  42.    if(eval("\x01") == 565)
  43.    {
  44.       set("\x01",eval("\x01") + 407);
  45.       continue;
  46.    }
  47.    if(eval("\x01") == 768)
  48.    {
  49.       set("\x01",eval("\x01") - 564);
  50.       if(!_global.mochi)
  51.       {
  52.          _global.mochi = new Object();
  53.       }
  54.       function ┬º\x04\x05┬º()
  55.       {
  56.          set("\x03",1038 % 511 * true);
  57.          ┬º┬ºpush("\x03");
  58.          if("\x01")
  59.          {
  60.          }
  61.          return eval(┬º┬ºpop());
  62.       }
  63.       if(!_global.mochi.as2)
  64.       {
  65.          _global.mochi.as2 = new Object();
  66.       }
  67.       ┬º┬ºpop();
  68.       if(!_global.mochi.as2.MochiAd)
  69.       {
  70.          var _loc2_ = mochi.as2.MochiAd = function()
  71.          {
  72.          }.prototype;
  73.          mochi.as2.MochiAd = function()
  74.          {
  75.          }.getVersion = function()
  76.          {
  77.             return "3.0 as2";
  78.          };
  79.          mochi.as2.MochiAd = function()
  80.          {
  81.          }.showPreGameAd = function(options)
  82.          {
  83.             var _loc26_ = {clip:_root,ad_timeout:3000,fadeout_time:250,regpt:"o",method:"showPreloaderAd",color:16747008,background:16777161,outline:13994812,no_progress_bar:false,ad_started:function()
  84.             {
  85.                this.clip.stop();
  86.             },ad_finished:function()
  87.             {
  88.                this.clip.play();
  89.             },ad_failed:function()
  90.             {
  91.                trace("[MochiAd] Couldn\'t load an ad, make sure that your game\'s local security sandbox is configured for Access Network Only and that you are not using ad blocking software");
  92.             },ad_loaded:function(width, height)
  93.             {
  94.             },ad_skipped:function()
  95.             {
  96.             },ad_progress:function(percent)
  97.             {
  98.             }};
  99.             options = mochi.as2.MochiAd._parseOptions(options,_loc26_);
  100.             if("c862232051e0a94e1c3609b3916ddb17".substr(0) == "dfeada81ac97cde83665f81c12da7def")
  101.             {
  102.                options.ad_started();
  103.                options.ad_finished();
  104.                return undefined;
  105.             }
  106.             var clip = options.clip;
  107.             var _loc22_ = 11000;
  108.             var _loc25_ = options.ad_timeout;
  109.             delete options.ad_timeout;
  110.             var fadeout_time = options.fadeout_time;
  111.             delete options.fadeout_time;
  112.             if(!mochi.as2.MochiAd.load(options))
  113.             {
  114.                options.ad_failed();
  115.                options.ad_finished();
  116.                return undefined;
  117.             }
  118.             options.ad_started();
  119.             var mc = clip._mochiad;
  120.             mc.onUnload = function()
  121.             {
  122.                options.ad_finished();
  123.             };
  124.             var _loc14_ = mochi.as2.MochiAd._getRes(options);
  125.             var _loc4_ = _loc14_[0];
  126.             var _loc13_ = _loc14_[1];
  127.             mc._x = _loc4_ * 0.5;
  128.             mc._y = _loc13_ * 0.5;
  129.             var chk = mc.createEmptyMovieClip("_mochiad_wait",3);
  130.             chk._x = _loc4_ * -0.5;
  131.             chk._y = _loc13_ * -0.5;
  132.             var _loc6_ = chk.createEmptyMovieClip("_mochiad_bar",4);
  133.             if(options.no_progress_bar)
  134.             {
  135.                _loc6_._visible = false;
  136.                delete options.no_progress_bar;
  137.             }
  138.             else
  139.             {
  140.                _loc6_._x = 10;
  141.                _loc6_._y = _loc13_ - 20;
  142.             }
  143.             var _loc21_ = options.color;
  144.             delete options.color;
  145.             var _loc19_ = options.background;
  146.             delete options.background;
  147.             var _loc23_ = options.outline;
  148.             delete options.outline;
  149.             var _loc5_ = _loc6_.createEmptyMovieClip("_outline",1);
  150.             _loc5_.beginFill(_loc19_);
  151.             _loc5_.moveTo(0,0);
  152.             _loc5_.lineTo(_loc4_ - 20,0);
  153.             _loc5_.lineTo(_loc4_ - 20,10);
  154.             _loc5_.lineTo(0,10);
  155.             _loc5_.lineTo(0,0);
  156.             _loc5_.endFill();
  157.             var _loc3_ = _loc6_.createEmptyMovieClip("_inside",2);
  158.             _loc3_.beginFill(_loc21_);
  159.             _loc3_.moveTo(0,0);
  160.             _loc3_.lineTo(_loc4_ - 20,0);
  161.             _loc3_.lineTo(_loc4_ - 20,10);
  162.             _loc3_.lineTo(0,10);
  163.             _loc3_.lineTo(0,0);
  164.             _loc3_.endFill();
  165.             _loc3_._xscale = 0;
  166.             var _loc7_ = _loc6_.createEmptyMovieClip("_outline",3);
  167.             _loc7_.lineStyle(0,_loc23_,100);
  168.             _loc7_.moveTo(0,0);
  169.             _loc7_.lineTo(_loc4_ - 20,0);
  170.             _loc7_.lineTo(_loc4_ - 20,10);
  171.             _loc7_.lineTo(0,10);
  172.             _loc7_.lineTo(0,0);
  173.             chk.ad_msec = _loc22_;
  174.             chk.ad_timeout = _loc25_;
  175.             chk.started = getTimer();
  176.             chk.showing = false;
  177.             chk.last_pcnt = 0;
  178.             chk.fadeout_time = fadeout_time;
  179.             chk.fadeFunction = function()
  180.             {
  181.                var _loc2_ = 100 * (1 - (getTimer() - this.fadeout_start) / this.fadeout_time);
  182.                if(_loc2_ > 0)
  183.                {
  184.                   this._parent._alpha = _loc2_;
  185.                }
  186.                else
  187.                {
  188.                   var _loc3_ = this._parent._parent;
  189.                   mochi.as2.MochiAd.unload(_loc3_);
  190.                   delete this.onEnterFrame;
  191.                }
  192.             };
  193.             mc.lc.regContLC = function(lc_name)
  194.             {
  195.                mc._containerLCName = lc_name;
  196.             };
  197.             var sendHostProgress = false;
  198.             mc.lc.sendHostLoadProgress = function(lc_name)
  199.             {
  200.                sendHostProgress = true;
  201.             };
  202.             mc.lc.adLoaded = options.ad_loaded;
  203.             mc.lc.adSkipped = options.ad_skipped;
  204.             mc.lc.adjustProgress = function(msec)
  205.             {
  206.                var _loc2_ = this.mc._mochiad_wait;
  207.                _loc2_.server_control = true;
  208.                _loc2_.started = getTimer();
  209.                _loc2_.ad_msec = msec;
  210.             };
  211.             mc.lc.rpc = function(callbackID, arg)
  212.             {
  213.                mochi.as2.MochiAd.rpc(clip,callbackID,arg);
  214.             };
  215.             mc.rpcTestFn = function(s)
  216.             {
  217.                trace("[MOCHIAD rpcTestFn] " + s);
  218.                return s;
  219.             };
  220.             chk.onEnterFrame = function()
  221.             {
  222.                var _loc6_ = this._parent._parent;
  223.                var _loc11_ = this._parent._mochiad_ctr;
  224.                var _loc5_ = getTimer() - this.started;
  225.                var _loc3_ = false;
  226.                var _loc4_ = _loc6_.getBytesTotal();
  227.                var _loc8_ = _loc6_.getBytesLoaded();
  228.                var _loc2_ = 100 * _loc8_ / _loc4_;
  229.                var _loc10_ = 100 * _loc5_ / chk.ad_msec;
  230.                var _loc9_ = this._mochiad_bar._inside;
  231.                var _loc13_ = Math.min(100,Math.min(_loc2_ || 0,_loc10_));
  232.                _loc13_ = Math.max(this.last_pcnt,_loc13_);
  233.                this.last_pcnt = _loc13_;
  234.                _loc9_._xscale = _loc13_;
  235.                options.ad_progress(_loc13_);
  236.                if(sendHostProgress)
  237.                {
  238.                   clip._mochiad.lc.send(clip._mochiad._containerLCName,"notify",{id:"hostLoadPcnt",pcnt:_loc2_});
  239.                   if(_loc2_ == 100)
  240.                   {
  241.                      sendHostProgress = false;
  242.                   }
  243.                }
  244.                if(!chk.showing)
  245.                {
  246.                   var _loc7_ = _loc11_.getBytesTotal();
  247.                   if(_loc7_ > 0 || typeof _loc7_ == "undefined")
  248.                   {
  249.                      chk.showing = true;
  250.                      chk.started = getTimer();
  251.                   }
  252.                   else if(_loc5_ > chk.ad_timeout && _loc2_ == 100)
  253.                   {
  254.                      options.ad_failed();
  255.                      _loc3_ = true;
  256.                   }
  257.                }
  258.                if(_loc5_ > chk.ad_msec)
  259.                {
  260.                   _loc3_ = true;
  261.                }
  262.                if(_loc4_ > 0 && _loc8_ >= _loc4_ && _loc3_)
  263.                {
  264.                   if(this.server_control)
  265.                   {
  266.                      delete this.onEnterFrame;
  267.                   }
  268.                   else
  269.                   {
  270.                      this.fadeout_start = getTimer();
  271.                      this.onEnterFrame = chk.fadeFunction;
  272.                   }
  273.                }
  274.             };
  275.          };
  276.          addr1041:
  277.          mochi.as2.MochiAd = function()
  278.          {
  279.          }.showClickAwayAd = function(options)
  280.          {
  281.             var _loc9_ = {clip:_root,ad_timeout:2000,fadeout_time:250,regpt:"o",method:"showClickAwayAd",res:"300x250",no_bg:true,ad_started:function()
  282.             {
  283.             },ad_finished:function()
  284.             {
  285.             },ad_loaded:function(width, height)
  286.             {
  287.             },ad_failed:function()
  288.             {
  289.                trace("[MochiAd] Couldn\'t load an ad, make sure that your game\'s local security sandbox is configured for Access Network Only and that you are not using ad blocking software");
  290.             },ad_skipped:function()
  291.             {
  292.             }};
  293.             options = mochi.as2.MochiAd._parseOptions(options,_loc9_);
  294.             var clip = options.clip;
  295.             var _loc8_ = options.ad_timeout;
  296.             delete options.ad_timeout;
  297.             if(!mochi.as2.MochiAd.load(options))
  298.             {
  299.                options.ad_failed();
  300.                options.ad_finished();
  301.                return undefined;
  302.             }
  303.             options.ad_started();
  304.             var mc = clip._mochiad;
  305.             mc.onUnload = function()
  306.             {
  307.                options.ad_finished();
  308.             };
  309.             var _loc4_ = mochi.as2.MochiAd._getRes(options);
  310.             var _loc10_ = _loc4_[0];
  311.             var _loc7_ = _loc4_[1];
  312.             mc._x = _loc10_ * 0.5;
  313.             mc._y = _loc7_ * 0.5;
  314.             var chk = mc.createEmptyMovieClip("_mochiad_wait",3);
  315.             chk.ad_timeout = _loc8_;
  316.             chk.started = getTimer();
  317.             chk.showing = false;
  318.             mc.lc.adLoaded = options.ad_loaded;
  319.             mc.lc.adSkipped = options.ad_skipped;
  320.             mc.lc.rpc = function(callbackID, arg)
  321.             {
  322.                mochi.as2.MochiAd.rpc(clip,callbackID,arg);
  323.             };
  324.             mc.rpcTestFn = function(s)
  325.             {
  326.                trace("[MOCHIAD rpcTestFn] " + s);
  327.                return s;
  328.             };
  329.             var _loc20_ = false;
  330.             mc.lc.regContLC = function(lc_name)
  331.             {
  332.                mc._containerLCName = lc_name;
  333.             };
  334.             chk.onEnterFrame = function()
  335.             {
  336.                var _loc5_ = this._parent._mochiad_ctr;
  337.                var _loc4_ = getTimer() - this.started;
  338.                var _loc2_ = false;
  339.                if(!chk.showing)
  340.                {
  341.                   var _loc3_ = _loc5_.getBytesTotal();
  342.                   if(_loc3_ > 0 || typeof _loc3_ == "undefined")
  343.                   {
  344.                      _loc2_ = true;
  345.                      chk.showing = true;
  346.                      chk.started = getTimer();
  347.                   }
  348.                   else if(_loc4_ > chk.ad_timeout)
  349.                   {
  350.                      options.ad_failed();
  351.                      _loc2_ = true;
  352.                   }
  353.                }
  354.                if(_loc2_)
  355.                {
  356.                   delete this.onEnterFrame;
  357.                }
  358.             };
  359.          };
  360.          mochi.as2.MochiAd = function()
  361.          {
  362.          }.showInterLevelAd = function(options)
  363.          {
  364.             var _loc13_ = {clip:_root,ad_timeout:2000,fadeout_time:250,regpt:"o",method:"showTimedAd",ad_started:function()
  365.             {
  366.                this.clip.stop();
  367.             },ad_finished:function()
  368.             {
  369.                this.clip.play();
  370.             },ad_failed:function()
  371.             {
  372.                trace("[MochiAd] Couldn\'t load an ad, make sure that your game\'s local security sandbox is configured for Access Network Only and that you are not using ad blocking software");
  373.             },ad_loaded:function(width, height)
  374.             {
  375.             },ad_skipped:function()
  376.             {
  377.             }};
  378.             options = mochi.as2.MochiAd._parseOptions(options,_loc13_);
  379.             var clip = options.clip;
  380.             var _loc10_ = 11000;
  381.             var _loc12_ = options.ad_timeout;
  382.             delete options.ad_timeout;
  383.             var fadeout_time = options.fadeout_time;
  384.             delete options.fadeout_time;
  385.             if(!mochi.as2.MochiAd.load(options))
  386.             {
  387.                options.ad_failed();
  388.                options.ad_finished();
  389.                return undefined;
  390.             }
  391.             options.ad_started();
  392.             var mc = clip._mochiad;
  393.             mc.onUnload = function()
  394.             {
  395.                options.ad_finished();
  396.             };
  397.             var _loc5_ = mochi.as2.MochiAd._getRes(options);
  398.             var _loc14_ = _loc5_[0];
  399.             var _loc11_ = _loc5_[1];
  400.             mc._x = _loc14_ * 0.5;
  401.             mc._y = _loc11_ * 0.5;
  402.             var chk = mc.createEmptyMovieClip("_mochiad_wait",3);
  403.             chk.ad_msec = _loc10_;
  404.             chk.ad_timeout = _loc12_;
  405.             chk.started = getTimer();
  406.             chk.showing = false;
  407.             chk.fadeout_time = fadeout_time;
  408.             chk.fadeFunction = function()
  409.             {
  410.                var _loc2_ = 100 * (1 - (getTimer() - this.fadeout_start) / this.fadeout_time);
  411.                if(_loc2_ > 0)
  412.                {
  413.                   this._parent._alpha = _loc2_;
  414.                }
  415.                else
  416.                {
  417.                   var _loc3_ = this._parent._parent;
  418.                   mochi.as2.MochiAd.unload(_loc3_);
  419.                   delete this.onEnterFrame;
  420.                }
  421.             };
  422.             mc.lc.adLoaded = options.ad_loaded;
  423.             mc.lc.adSkipped = options.ad_skipped;
  424.             mc.lc.adjustProgress = function(msec)
  425.             {
  426.                var _loc2_ = this.mc._mochiad_wait;
  427.                _loc2_.server_control = true;
  428.                _loc2_.started = getTimer();
  429.                _loc2_.ad_msec = msec - 250;
  430.             };
  431.             mc.lc.rpc = function(callbackID, arg)
  432.             {
  433.                mochi.as2.MochiAd.rpc(clip,callbackID,arg);
  434.             };
  435.             mc.rpcTestFn = function(s)
  436.             {
  437.                trace("[MOCHIAD rpcTestFn] " + s);
  438.                return s;
  439.             };
  440.             chk.onEnterFrame = function()
  441.             {
  442.                var _loc5_ = this._parent._mochiad_ctr;
  443.                var _loc4_ = getTimer() - this.started;
  444.                var _loc2_ = false;
  445.                if(!chk.showing)
  446.                {
  447.                   var _loc3_ = _loc5_.getBytesTotal();
  448.                   if(_loc3_ > 0 || typeof _loc3_ == "undefined")
  449.                   {
  450.                      chk.showing = true;
  451.                      chk.started = getTimer();
  452.                   }
  453.                   else if(_loc4_ > chk.ad_timeout)
  454.                   {
  455.                      options.ad_failed();
  456.                      _loc2_ = true;
  457.                   }
  458.                }
  459.                if(_loc4_ > chk.ad_msec)
  460.                {
  461.                   _loc2_ = true;
  462.                }
  463.                if(_loc2_)
  464.                {
  465.                   if(this.server_control)
  466.                   {
  467.                      delete this.onEnterFrame;
  468.                   }
  469.                   else
  470.                   {
  471.                      this.fadeout_start = getTimer();
  472.                      this.onEnterFrame = this.fadeFunction;
  473.                   }
  474.                }
  475.             };
  476.          };
  477.          mochi.as2.MochiAd = function()
  478.          {
  479.          }.showPreloaderAd = function(options)
  480.          {
  481.             trace("[MochiAd] DEPRECATED: showPreloaderAd was renamed to showPreGameAd in 2.0");
  482.             mochi.as2.MochiAd.showPreGameAd(options);
  483.          };
  484.          mochi.as2.MochiAd = function()
  485.          {
  486.          }.showTimedAd = function(options)
  487.          {
  488.             trace("[MochiAd] DEPRECATED: showTimedAd was renamed to showInterLevelAd in 2.0");
  489.             mochi.as2.MochiAd.showInterLevelAd(options);
  490.          };
  491.          mochi.as2.MochiAd = function()
  492.          {
  493.          }._allowDomains = function(server)
  494.          {
  495.             var _loc1_ = server.split("/")[2].split(":")[0];
  496.             if(System.security)
  497.             {
  498.                if(System.security.allowDomain)
  499.                {
  500.                   System.security.allowDomain("*");
  501.                   System.security.allowDomain(_loc1_);
  502.                }
  503.                if(System.security.allowInsecureDomain)
  504.                {
  505.                   System.security.allowInsecureDomain("*");
  506.                   System.security.allowInsecureDomain(_loc1_);
  507.                }
  508.             }
  509.             return _loc1_;
  510.          };
  511.          mochi.as2.MochiAd = function()
  512.          {
  513.          }.load = function(options)
  514.          {
  515.             var _loc13_ = {clip:_root,server:"http://x.mochiads.com/srv/1/",method:"load",depth:10333,id:"_UNKNOWN_"};
  516.             options = mochi.as2.MochiAd._parseOptions(options,_loc13_);
  517.             options.swfv = options.clip.getSWFVersion() || 6;
  518.             options.mav = mochi.as2.MochiAd.getVersion();
  519.             var _loc7_ = options.clip;
  520.             if(!mochi.as2.MochiAd._isNetworkAvailable())
  521.             {
  522.                return null;
  523.             }
  524.             if(_loc7_._mochiad_loaded)
  525.             {
  526.                return null;
  527.             }
  528.             var _loc12_ = options.depth;
  529.             delete options.depth;
  530.             var _loc6_ = _loc7_.createEmptyMovieClip("_mochiad",_loc12_);
  531.             var _loc11_ = mochi.as2.MochiAd._getRes(options);
  532.             options.res = _loc11_[0] + "x" + _loc11_[1];
  533.             options.server += options.id;
  534.             delete options.id;
  535.             _loc7_._mochiad_loaded = true;
  536.             if(_loc7_._url.indexOf("http") != 0)
  537.             {
  538.                trace("[MochiAd] NOTE: Security Sandbox Violation errors below are normal");
  539.             }
  540.             var _loc4_ = _loc6_.createEmptyMovieClip("_mochiad_ctr",1);
  541.             for(var _loc8_ in options)
  542.             {
  543.                _loc4_[_loc8_] = options[_loc8_];
  544.             }
  545.             var _loc10_ = _loc4_.server;
  546.             delete _loc4_.server;
  547.             var _loc14_ = mochi.as2.MochiAd._allowDomains(_loc10_);
  548.             _loc6_.onEnterFrame = function()
  549.             {
  550.                if(this._mochiad_ctr._url != this._url)
  551.                {
  552.                   this.onEnterFrame = function()
  553.                   {
  554.                      if(!this._mochiad_ctr)
  555.                      {
  556.                         delete this.onEnterFrame;
  557.                         mochi.as2.MochiAd.unload(this._parent);
  558.                      }
  559.                   };
  560.                }
  561.             };
  562.             var _loc5_ = new LocalConnection();
  563.             var _loc9_ = ["",Math.floor(new Date().getTime()),random(999999)].join("_");
  564.             _loc5_.mc = _loc6_;
  565.             _loc5_.name = _loc9_;
  566.             _loc5_.hostname = _loc14_;
  567.             _loc5_.allowDomain = function(d)
  568.             {
  569.                return true;
  570.             };
  571.             _loc5_.allowInsecureDomain = _loc5_.allowDomain;
  572.             _loc5_.connect(_loc9_);
  573.             _loc6_.lc = _loc5_;
  574.             _loc4_.lc = _loc9_;
  575.             _loc4_.st = getTimer();
  576.             _loc4_.loadMovie(_loc10_ + ".swf","POST");
  577.             return _loc6_;
  578.          };
  579.          mochi.as2.MochiAd = function()
  580.          {
  581.          }.unload = function(clip)
  582.          {
  583.             if(typeof clip == "undefined")
  584.             {
  585.                clip = _root;
  586.             }
  587.             if(clip.clip && clip.clip._mochiad)
  588.             {
  589.                clip = clip.clip;
  590.             }
  591.             if(!clip._mochiad)
  592.             {
  593.                return false;
  594.             }
  595.             if(clip._mochiad._containerLCName != undefined)
  596.             {
  597.                clip._mochiad.lc.send(clip._mochiad._containerLCName,"notify",{id:"unload"});
  598.             }
  599.             clip._mochiad.removeMovieClip();
  600.             delete clip._mochiad_loaded;
  601.             delete clip._mochiad;
  602.             return true;
  603.          };
  604.          mochi.as2.MochiAd = function()
  605.          {
  606.          }._isNetworkAvailable = function()
  607.          {
  608.             if(System.security)
  609.             {
  610.                var _loc1_ = System.security;
  611.                if(_loc1_.sandboxType == "localWithFile")
  612.                {
  613.                   return false;
  614.                }
  615.             }
  616.             return true;
  617.          };
  618.          mochi.as2.MochiAd = function()
  619.          {
  620.          }._getRes = function(options)
  621.          {
  622.             var _loc3_ = options.clip.getBounds();
  623.             var _loc2_ = 0;
  624.             var _loc1_ = 0;
  625.             if(typeof options.res != "undefined")
  626.             {
  627.                var _loc4_ = options.res.split("x");
  628.                _loc2_ = parseFloat(_loc4_[0]);
  629.                _loc1_ = parseFloat(_loc4_[1]);
  630.             }
  631.             else
  632.             {
  633.                _loc2_ = _loc3_.xMax - _loc3_.xMin;
  634.                _loc1_ = _loc3_.yMax - _loc3_.yMin;
  635.             }
  636.             if(_loc2_ == 0 || _loc1_ == 0)
  637.             {
  638.                _loc2_ = Stage.width;
  639.                _loc1_ = Stage.height;
  640.             }
  641.             return [_loc2_,_loc1_];
  642.          };
  643.          mochi.as2.MochiAd = function()
  644.          {
  645.          }._parseOptions = function(options, defaults)
  646.          {
  647.             var _loc4_ = {};
  648.             for(var _loc8_ in defaults)
  649.             {
  650.                _loc4_[_loc8_] = defaults[_loc8_];
  651.             }
  652.             if(options)
  653.             {
  654.                for(_loc8_ in options)
  655.                {
  656.                   _loc4_[_loc8_] = options[_loc8_];
  657.                }
  658.             }
  659.             if(_root.mochiad_options)
  660.             {
  661.                var _loc5_ = _root.mochiad_options.split("&");
  662.                var _loc2_ = 0;
  663.                while(_loc2_ < _loc5_.length)
  664.                {
  665.                   var _loc3_ = _loc5_[_loc2_].split("=");
  666.                   _loc4_[unescape(_loc3_[0])] = unescape(_loc3_[1]);
  667.                   _loc2_ = _loc2_ + 1;
  668.                }
  669.             }
  670.             if(_loc4_.id == "test")
  671.             {
  672.                trace("[MochiAd] WARNING: Using the MochiAds test identifier, make sure to use the code from your dashboard, not this example!");
  673.             }
  674.             return _loc4_;
  675.          };
  676.          mochi.as2.MochiAd = function()
  677.          {
  678.          }.rpc = function(clip, callbackID, arg)
  679.          {
  680.             switch(arg.id)
  681.             {
  682.                case "setValue":
  683.                   mochi.as2.MochiAd.setValue(clip,arg.objectName,arg.value);
  684.                   break;
  685.                case "getValue":
  686.                   var _loc4_ = mochi.as2.MochiAd.getValue(clip,arg.objectName);
  687.                   clip._mochiad.lc.send(clip._mochiad._containerLCName,"rpcResult",callbackID,_loc4_);
  688.                   break;
  689.                case "runMethod":
  690.                   var _loc3_ = mochi.as2.MochiAd.runMethod(clip,arg.method,arg.args);
  691.                   clip._mochiad.lc.send(clip._mochiad._containerLCName,"rpcResult",callbackID,_loc3_);
  692.                   break;
  693.                default:
  694.                   trace("[mochiads rpc] unknown rpc id: " + arg.id);
  695.             }
  696.          };
  697.          mochi.as2.MochiAd = function()
  698.          {
  699.          }.setValue = function(base, objectName, value)
  700.          {
  701.             var _loc2_ = objectName.split(".");
  702.             var _loc1_ = undefined;
  703.             _loc1_ = 0;
  704.             while(_loc1_ < _loc2_.length - 1)
  705.             {
  706.                if(base[_loc2_[_loc1_]] == undefined || base[_loc2_[_loc1_]] == null)
  707.                {
  708.                   return undefined;
  709.                }
  710.                base = base[_loc2_[_loc1_]];
  711.                _loc1_ = _loc1_ + 1;
  712.             }
  713.             base[_loc2_[_loc1_]] = value;
  714.          };
  715.          mochi.as2.MochiAd = function()
  716.          {
  717.          }.getValue = function(base, objectName)
  718.          {
  719.             var _loc2_ = objectName.split(".");
  720.             var _loc1_ = undefined;
  721.             _loc1_ = 0;
  722.             while(_loc1_ < _loc2_.length - 1)
  723.             {
  724.                if(base[_loc2_[_loc1_]] == undefined || base[_loc2_[_loc1_]] == null)
  725.                {
  726.                   return undefined;
  727.                }
  728.                base = base[_loc2_[_loc1_]];
  729.                _loc1_ = _loc1_ + 1;
  730.             }
  731.             return base[_loc2_[_loc1_]];
  732.          };
  733.          mochi.as2.MochiAd = function()
  734.          {
  735.          }.runMethod = function(base, methodName, argsArray)
  736.          {
  737.             var _loc2_ = methodName.split(".");
  738.             var _loc1_ = undefined;
  739.             _loc1_ = 0;
  740.             while(_loc1_ < _loc2_.length - 1)
  741.             {
  742.                if(base[_loc2_[_loc1_]] == undefined || base[_loc2_[_loc1_]] == null)
  743.                {
  744.                   return undefined;
  745.                }
  746.                base = base[_loc2_[_loc1_]];
  747.                _loc1_ = _loc1_ + 1;
  748.             }
  749.             if(typeof base[_loc2_[_loc1_]] == "function")
  750.             {
  751.                return base[_loc2_[_loc1_]].apply(base,argsArray);
  752.             }
  753.             return undefined;
  754.          };
  755.          ┬º┬ºpush(ASSetPropFlags(mochi.as2.MochiAd.prototype,null,1));
  756.       }
  757.       ┬º┬ºpop();
  758.       break;
  759.    }
  760.    if(eval("\x01") == 606)
  761.    {
  762.       set("\x01",eval("\x01") - 359);
  763.       break;
  764.    }
  765.    if(eval("\x01") == 400)
  766.    {
  767.       set("\x01",eval("\x01") + 368);
  768.       continue;
  769.    }
  770.    if(eval("\x01") == 204)
  771.    {
  772.       set("\x01",eval("\x01") - 204);
  773.       break;
  774.    }
  775.    if(eval("\x01") == 72)
  776.    {
  777.       set("\x01",eval("\x01") + 328);
  778.       if(function ┬º\x04\x05┬º()
  779.       {
  780.          set("\x03",1038 % 511 * true);
  781.          ┬º┬ºpush("\x03");
  782.          if("\x01")
  783.          {
  784.          }
  785.          return eval(┬º┬ºpop());
  786.       })
  787.       {
  788.          set("\x01",eval("\x01") + 368);
  789.       }
  790.       continue;
  791.    }
  792.    if(eval("\x01") == 73)
  793.    {
  794.       set("\x01",eval("\x01") + 899);
  795.       continue;
  796.    }
  797.    if(eval("\x01") == 859)
  798.    {
  799.       set("\x01",eval("\x01") - 479);
  800.       ┬º┬ºpush(true);
  801.       continue;
  802.    }
  803.    if(eval("\x01") == 823)
  804.    {
  805.       set("\x01",eval("\x01") - 200);
  806.       var ┬º┬ºpop() = function ┬º\x04\x05┬º()
  807.       {
  808.          set("\x03",1038 % 511 * true);
  809.          ┬º┬ºpush("\x03");
  810.          if("\x01")
  811.          {
  812.          }
  813.          return eval(┬º┬ºpop());
  814.       };
  815.       continue;
  816.    }
  817.    if(eval("\x01") == 701)
  818.    {
  819.       set("\x01",eval("\x01") + 122);
  820.       ┬º┬ºpush("\x0f");
  821.       ┬º┬ºpush(1);
  822.       continue;
  823.    }
  824.    if(eval("\x01") == 247)
  825.    {
  826.       set("\x01",eval("\x01") + 612);
  827.       continue;
  828.    }
  829.    if(eval("\x01") == 534)
  830.    {
  831.       set("\x01",eval("\x01") - 462);
  832.       ┬º┬ºpush(!function ┬º\x04\x05┬º()
  833.       {
  834.          set("\x03",1038 % 511 * true);
  835.          ┬º┬ºpush("\x03");
  836.          if("\x01")
  837.          {
  838.          }
  839.          return eval(┬º┬ºpop());
  840.       });
  841.       continue;
  842.    }
  843.    if(eval("\x01") == 650)
  844.    {
  845.       set("\x01",eval("\x01") - 116);
  846.       ┬º┬ºpush(eval(function ┬º\x04\x05┬º()
  847.       {
  848.          set("\x03",1038 % 511 * true);
  849.          ┬º┬ºpush("\x03");
  850.          if("\x01")
  851.          {
  852.          }
  853.          return eval(┬º┬ºpop());
  854.       }));
  855.       continue;
  856.    }
  857.    if(eval("\x01") == 623)
  858.    {
  859.       set("\x01",eval("\x01") + 27);
  860.       ┬º┬ºpush("\x0f");
  861.       continue;
  862.    }
  863.    if(eval("\x01") != 943)
  864.    {
  865.       if(eval("\x01") == 19)
  866.       {
  867.          set("\x01",eval("\x01") + 682);
  868.       }
  869.       else if(eval("\x01") == 817)
  870.       {
  871.          set("\x01",eval("\x01") - 211);
  872.          if(function ┬º\x04\x05┬º()
  873.          {
  874.             set("\x03",1038 % 511 * true);
  875.             ┬º┬ºpush("\x03");
  876.             if("\x01")
  877.             {
  878.             }
  879.             return eval(┬º┬ºpop());
  880.          })
  881.          {
  882.             set("\x01",eval("\x01") - 359);
  883.          }
  884.       }
  885.       else if(eval("\x01") == 533)
  886.       {
  887.          set("\x01",eval("\x01") + 168);
  888.       }
  889.       else if(eval("\x01") == 547)
  890.       {
  891.          set("\x01",eval("\x01") + 312);
  892.       }
  893.       else
  894.       {
  895.          if(eval("\x01") == 596)
  896.          {
  897.             set("\x01",eval("\x01") - 577);
  898.             var ┬º┬ºpop() = ┬º┬ºpop() gt (┬º┬ºpop() | ┬º┬ºpop() === function ┬º\x04\x05┬º()
  899.             {
  900.                set("\x03",1038 % 511 * true);
  901.                ┬º┬ºpush("\x03");
  902.                if("\x01")
  903.                {
  904.                }
  905.                return eval(┬º┬ºpop());
  906.             });
  907.             return ┬º┬ºpop() | ┬º┬ºpop() === delete ┬º┬ºpop()[┬º┬ºpop() << (┬º┬ºpop() >> ┬º┬ºpop())];
  908.          }
  909.          if(eval("\x01") != 380)
  910.          {
  911.             break;
  912.          }
  913.          set("\x01",eval("\x01") + 216);
  914.          if(function ┬º\x04\x05┬º()
  915.          {
  916.             set("\x03",1038 % 511 * true);
  917.             ┬º┬ºpush("\x03");
  918.             if("\x01")
  919.             {
  920.             }
  921.             return eval(┬º┬ºpop());
  922.          })
  923.          {
  924.             set("\x01",eval("\x01") - 577);
  925.          }
  926.       }
  927.       continue;
  928.    }
  929.    set("\x01",eval("\x01") - 870);
  930.    function ┬º\x04\x05┬º()
  931.    {
  932.       set("\x03",1038 % 511 * true);
  933.       ┬º┬ºpush("\x03");
  934.       if("\x01")
  935.       {
  936.       }
  937.       return eval(┬º┬ºpop());
  938.    }.onUnload = function()
  939.    {
  940.       options.ad_finished();
  941.    };
  942.    var _loc4_ = mochi.as2.MochiAd._getRes(options);
  943.    var _loc10_ = _loc4_[0];
  944.    var _loc7_ = _loc4_[1];
  945.    mc._x = _loc10_ * 0.5;
  946.    mc._y = _loc7_ * 0.5;
  947.    var chk = mc.createEmptyMovieClip("_mochiad_wait",3);
  948.    chk.ad_timeout = _loc8_;
  949.    chk.started = getTimer();
  950.    chk.showing = false;
  951.    mc.lc.adLoaded = options.ad_loaded;
  952.    mc.lc.adSkipped = options.ad_skipped;
  953.    mc.lc.rpc = function(callbackID, arg)
  954.    {
  955.       mochi.as2.MochiAd.rpc(clip,callbackID,arg);
  956.    };
  957.    mc.rpcTestFn = function(s)
  958.    {
  959.       trace("[MOCHIAD rpcTestFn] " + s);
  960.       return s;
  961.    };
  962.    var _loc20_ = false;
  963.    mc.lc.regContLC = function(lc_name)
  964.    {
  965.       mc._containerLCName = lc_name;
  966.    };
  967.    chk.onEnterFrame = function()
  968.    {
  969.       var _loc5_ = this._parent._mochiad_ctr;
  970.       var _loc4_ = getTimer() - this.started;
  971.       var _loc2_ = false;
  972.       if(!chk.showing)
  973.       {
  974.          var _loc3_ = _loc5_.getBytesTotal();
  975.          if(_loc3_ > 0 || typeof _loc3_ == "undefined")
  976.          {
  977.             _loc2_ = true;
  978.             chk.showing = true;
  979.             chk.started = getTimer();
  980.          }
  981.          else if(_loc4_ > chk.ad_timeout)
  982.          {
  983.             options.ad_failed();
  984.             _loc2_ = true;
  985.          }
  986.       }
  987.       if(_loc2_)
  988.       {
  989.          delete this.onEnterFrame;
  990.       }
  991.    };
  992.    ┬º┬ºgoto(addr1041);
  993. }
  994.